в 15:31, 26 мая 2010

2010-05-26T15:31:18Z

Admin: 1 версия

2010-05-26T11:39:28Z

1 версия

Новая страница

==calls GetBaseException and outputs the error message of the initial exception.==

<source lang="csharp">
using System;
public class Starter {
public static void Main() {
try {
MethodA();
} catch (Exception except) {
Exception original = except.GetBaseException();
Console.WriteLine(original.Message);
}
}
public static void MethodA() {
try {
MethodB();
} catch (Exception except) {
throw new ApplicationException("Inner Exception", except);
}
}
public static void MethodB() {
throw new ApplicationException("Innermost Exception");
}
}
</source>

==Demonstrates defining and using a custom exception class==

<source lang="csharp">
/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa
Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
//
// CustExcp.cs -- Demonstrates defining and using a custom exception class
//
// Compile this program with the following command line:
// C:>csc CustExcp.cs
//
namespace nsCustomException
{
using System;
using System.IO;

public class CustExcpclsMain
{
static public void Main (string [] args)
{
if (args.Length < 2)
{
Console.WriteLine ("usage: CustExcp FileName String");
return;
}
try
{
ReadFile (args[0], args[1]);
Console.WriteLine (args[1] + " was not found in " + args[0]);
}
// Custom exception thrown. Display the information.
catch (clsException e)
{
Console.WriteLine ("string {0} first occurs in {1} at Line {2}, Column {3}",
args[1], args[0], e.Line, e.Column);
Console.WriteLine (e.Found);
return;
}
// Check for other possible exceptions.
catch (ArgumentException)
{
Console.WriteLine ("The file name " + args [0] +
" is empty or contains an invalid character");
}
catch (FileNotFoundException)
{
Console.WriteLine ("The file name " + args [0] +
" cannot be found");
}
catch (DirectoryNotFoundException)
{
Console.WriteLine ("The path for " + args [0] +
" is invalid");
}
catch (Exception e)
{
Console.WriteLine (e);
}
}
static public void ReadFile (string FileName, string Find)
{
FileStream strm;
StreamReader reader;
try
{
strm = new FileStream (FileName, FileMode.Open);
reader = new StreamReader (strm);
int Line = 0;
while (reader.Peek () >= 0)
{
++Line;
string str = reader.ReadLine ();
int index = str.IndexOf (Find);
if (index >= 0)
{
reader.Close ();
strm.Close ();
clsException ex = new clsException ();
ex.Line = Line;
ex.Column = index + 1;
ex.Found = str;
throw (ex);
}
}
reader.Close ();
strm.Close ();
return;
}
catch (IOException e)
{
// If file not found, go back and get another name
if (e is FileNotFoundException)
throw (e);
// Code here to handle other IOException classes
Console.WriteLine (e.Message);
throw (new IOException());
}
}
}
// Define a class derived from Exception
class clsException : Exception
{
public int Line = 0;
public int Column = 0;
public string Found = null;
}
}

</source>

==Derived exceptions must appear before base class exceptions==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Derived exceptions must appear before base class exceptions.

using System;

// Create an exception.
class ExceptA : ApplicationException {
public ExceptA() : base() { }
public ExceptA(string str) : base(str) { }

public override string ToString() {
return Message;
}
}

// Create an exception derived from ExceptA
class ExceptB : ExceptA {
public ExceptB() : base() { }
public ExceptB(string str) : base(str) { }

public override string ToString() {
return Message;
}
}

public class OrderMatters {
public static void Main() {
for(int x = 0; x < 3; x++) {
try {
if(x==0) throw new ExceptA("Caught an ExceptA exception");
else if(x==1) throw new ExceptB("Caught an ExceptB exception");
else throw new Exception();
}
catch (ExceptB exc) {
// catch the exception
Console.WriteLine(exc);
}
catch (ExceptA exc) {
// catch the exception
Console.WriteLine(exc);
}
catch (Exception exc) {
Console.WriteLine(exc);
}
}
}
}

</source>

==Exception handle with your own exception class==

<source lang="csharp">
/*
Learning C#
by Jesse Liberty
Publisher: O"Reilly
ISBN: 0596003765
*/
using System;
namespace ExceptionHandling
{
// custom exception class
class MyCustomException :
System.ApplicationException
{
public MyCustomException(string message):
base(message) // pass the message up to the base class
{
}
}
public class TesterExceptionHandling
{
public void Run()
{
try
{
Console.WriteLine("Open file here");
double a = 0;
double b = 5;
Console.WriteLine ("{0} / {1} = {2}",
a, b, DoDivide(a,b));
Console.WriteLine (
"This line may or may not print");
}
// most derived exception type first
catch (System.DivideByZeroException e)
{
Console.WriteLine(
"\nDivideByZeroException! Msg: {0}",
e.Message);
Console.WriteLine(
"\nHelpLink: {0}\n", e.HelpLink);
}
// catch custom exception
catch (MyCustomException e)
{
Console.WriteLine(
"\nMyCustomException! Msg: {0}",
e.Message);
Console.WriteLine(
"\nHelpLink: {0}\n", e.HelpLink);
}
catch // catch any uncaught exceptions
{
Console.WriteLine(
"Unknown exception caught");
}
finally
{
Console.WriteLine ("Close file here.");
}
}
// do the division if legal
public double DoDivide(double a, double b)
{
if (b == 0)
{
DivideByZeroException e =
new DivideByZeroException();
e.HelpLink=
"http://www.libertyassociates.ru";
throw e;
}
if (a == 0)
{
// create a custom exception instance
MyCustomException e =
new MyCustomException(
"Can"t have zero divisor");
e.HelpLink =
"http://www.libertyassociates.ru/NoZeroDivisor.htm";
throw e;
}
return a/b;
}
static void Main()
{
Console.WriteLine("Enter Main...");
TesterExceptionHandling t = new TesterExceptionHandling();
t.Run();
Console.WriteLine("Exit Main...");
}
}
}

</source>

==Exception Handling: The Exception Hierarchy 1==

<source lang="csharp">
using System;

public class ExceptionHierarchy
{
static int Zero = 0;
public static void Main()
{
try
{
int j = 22 / Zero;
}
// catch a specific exception
catch (DivideByZeroException e)
{
Console.WriteLine("DivideByZero {0}", e);
}
// catch any remaining exceptions
catch (Exception e)
{
Console.WriteLine("Exception {0}", e);
}
}
}

</source>

==Exception Handling: The Exception Hierarchy 2==

<source lang="csharp">
using System;
public class ExceptionHierarchyNeverExecuted
{
static int Zero = 0;
static void AFunction()
{
int j = 22 / Zero;
Console.WriteLine("In AFunction()");
}
public static void Main()
{
try
{
AFunction();
}
catch (DivideByZeroException e)
{
Console.WriteLine("DivideByZero {0}", e);
}
}
}

</source>

==Exception Handling: The Exception Hierarchy 3==

<source lang="csharp">
using System;
public class ExceptionHierarchyOutOfRangeException
{
static int Zero = 0;
static void AFunction()
{
try
{
int j = 22 / Zero;
}
// this exception doesn"t match
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine("OutOfRangeException: {0}", e);
}
Console.WriteLine("In AFunction()");
}
public static void Main()
{
try
{
AFunction();
}
// this exception doesn"t match
catch (ArgumentException e)
{
Console.WriteLine("ArgumentException {0}", e);
}
}
}

</source>

==Exception Handling User-Defined Exception Classes==

<source lang="csharp">
/*
A Programmer"s Introduction to C# (Second Edition)
by Eric Gunnerson
Publisher: Apress L.P.
ISBN: 1-893115-62-3
*/
// 04 - Exception Handling\User-Defined Exception Classes
// copyright 2000 Eric Gunnerson
using System;
public class UserDefinedExceptionClasses
{
public static void Main()
{
Summer summer = new Summer();
try
{
summer.DoAverage();
}
catch (CountIsZeroException e)
{
Console.WriteLine("CountIsZeroException: {0}", e);
}
}
}
public class CountIsZeroException: ApplicationException
{
public CountIsZeroException()
{
}
public CountIsZeroException(string message)
: base(message)
{
}
public CountIsZeroException(string message, Exception inner)
: base(message, inner)
{
}
}
public class Summer
{
int sum = 0;
int count = 0;
float average;
public void DoAverage()
{
if (count == 0)
throw(new CountIsZeroException("Zero count in DoAverage"));
else
average = sum / count;
}
}

</source>

==illustrates a custom exception==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example13_9.cs illustrates a custom exception
*/
using System;

// declare the CustomException class
class CustomException : ApplicationException
{
public CustomException(string Message) : base(Message)
{
// set the HelpLink and Source properties
this.HelpLink = "See the Readme.txt file";
this.Source = "My Example13_9 Program";
}
}

public class Example13_9
{
public static void Main()
{
try
{
// throw a new CustomException object
Console.WriteLine("Throwing a new CustomException object");
throw new CustomException("My CustomException message");
}
catch (CustomException e)
{
// display the CustomException object"s properties
Console.WriteLine("HelpLink = " + e.HelpLink);
Console.WriteLine("Message = " + e.Message);
Console.WriteLine("Source = " + e.Source);
Console.WriteLine("StackTrace = " + e.StackTrace);
Console.WriteLine("TargetSite = " + e.TargetSite);
}
}
}

</source>

==illustrates the use of a System.Exception object==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example13_2.cs illustrates the use of a
System.Exception object
*/
using System;
public class Example13_2
{
public static void Main()
{
try
{
int zero = 0;
Console.WriteLine("In try block: attempting division by zero");
int myInt = 1 / zero; // throws the exception
}
catch (System.Exception myException)
{
// display the exception object"s properties
Console.WriteLine("HelpLink = " + myException.HelpLink);
Console.WriteLine("Message = " + myException.Message);
Console.WriteLine("Source = " + myException.Source);
Console.WriteLine("StackTrace = " + myException.StackTrace);
Console.WriteLine("TargetSite = " + myException.TargetSite);
}
}
}

</source>

==refines the System.Exception base class with name of the type and time of exception to create your own Exception==

<source lang="csharp">
using System;
public class ConstructorException : Exception {
public ConstructorException(object origin)
: this(origin, null) {
}
public ConstructorException(object origin, Exception innerException)
: base("Exception in constructor", innerException) {
prop_Typename = origin.GetType().Name;
prop_Time = DateTime.Now.ToLongDateString() + " " +
DateTime.Now.ToShortTimeString();
}
protected string prop_Typename = null;
public string Typename {
get {
return prop_Typename;
}
}
protected string prop_Time = null;
public string Time {
get {
return prop_Time;
}
}
}
public class Starter {
public static void Main() {
try {
MyClass obj = new MyClass();
} catch (ConstructorException except) {
Console.WriteLine(except.Message);
Console.WriteLine("Typename: " + except.Typename);
Console.WriteLine("Occured: " + except.Time);
}
}
}
class MyClass {
public MyClass() {
// initialization fails
throw new ConstructorException(this);
}
}
</source>

==Use a custom Exception for RangeArray errors==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use a custom Exception for RangeArray errors.

using System;

// Create an RangeArray exception.
class RangeArrayException : ApplicationException {
// Implement the standard constructors
public RangeArrayException() : base() { }
public RangeArrayException(string str) : base(str) { }

// Override ToString for RangeArrayException.
public override string ToString() {
return Message;
}
}

// An improved version of RangeArray.
class RangeArray {
// private data
int[] a; // reference to underlying array
int lowerBound; // lowest index
int upperBound; // greatest index

int len; // underlying var for Length property

// Construct array given its size.
public RangeArray(int low, int high) {
high++;
if(high <= low) {
throw new RangeArrayException("Low index not less than high.");
}
a = new int[high - low];
len = high - low;

lowerBound = low;
upperBound = --high;
}

// Read-only Length property.
public int Length {
get {
return len;
}
}

// This is the indexer for RangeArray.
public int this[int index] {
// This is the get accessor.
get {
if(ok(index)) {
return a[index - lowerBound];
} else {
throw new RangeArrayException("Range Error.");
}
}

// This is the set accessor.
set {
if(ok(index)) {
a[index - lowerBound] = value;
}
else throw new RangeArrayException("Range Error.");
}
}

// Return true if index is within bounds.
private bool ok(int index) {
if(index >= lowerBound & index <= upperBound) return true;
return false;
}
}

// Demonstrate the index-range array.
public class RangeArrayDemo1 {
public static void Main() {
try {
RangeArray ra = new RangeArray(-5, 5);
RangeArray ra2 = new RangeArray(1, 10);

// Demonstrate ra
Console.WriteLine("Length of ra: " + ra.Length);

for(int i = -5; i <= 5; i++)
ra[i] = i;

Console.Write("Contents of ra: ");
for(int i = -5; i <= 5; i++)
Console.Write(ra[i] + " ");

Console.WriteLine("\n");

// Demonstrate ra2
Console.WriteLine("Length of ra2: " + ra2.Length);

for(int i = 1; i <= 10; i++)
ra2[i] = i;

Console.Write("Contents of ra2: ");
for(int i = 1; i <= 10; i++)
Console.Write(ra2[i] + " ");

Console.WriteLine("\n");

} catch (RangeArrayException exc) {
Console.WriteLine(exc);
}

// Now, demonstrate some errors.
Console.WriteLine("Now generate some range errors.");

// Use an invalid constructor.
try {
RangeArray ra3 = new RangeArray(100, -10); // Error

} catch (RangeArrayException exc) {
Console.WriteLine(exc);
}

// Use an invalid index.
try {
RangeArray ra3 = new RangeArray(-2, 2);

for(int i = -2; i <= 2; i++)
ra3[i] = i;

Console.Write("Contents of ra3: ");
for(int i = -2; i <= 10; i++) // generate range error
Console.Write(ra3[i] + " ");

} catch (RangeArrayException exc) {
Console.WriteLine(exc);
}
}
}

</source>

==uses some of the properties of the Exception class==

<source lang="csharp">
using System;
using System.Reflection;
public class Starter {
public static bool bException = true;
public static void Main() {
try {
MethodA();
} catch (Exception except) {
Console.WriteLine(except.Message);
bException = false;
except.TargetSite.Invoke(null, null);
}
}
public static void MethodA() {
if (bException) {
throw new ApplicationException("exception message");
}
}
}
</source>

==Use the NullReferenceException==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Use the NullReferenceException.

using System;

class X {
int x;
public X(int a) {
x = a;
}

public int add(X o) {
return x + o.x;
}
}

// Demonstrate NullReferenceException.
public class NREDemo {
public static void Main() {
X p = new X(10);
X q = null; // q is explicitly assigned null
int val;

try {
val = p.add(q); // this will lead to an exception
} catch (NullReferenceException) {
Console.WriteLine("NullReferenceException!");
Console.WriteLine("fixing...\n");

// now, fix it
q = new X(9);
val = p.add(q);
}

Console.WriteLine("val is {0}", val);

}
}

</source>

==Using checked and unchecked==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Using checked and unchecked.

using System;

public class CheckedDemo {
public static void Main() {
byte a, b;
byte result;

a = 127;
b = 127;

try {
result = unchecked((byte)(a * b));
Console.WriteLine("Unchecked result: " + result);

result = checked((byte)(a * b)); // this causes exception
Console.WriteLine("Checked result: " + result); // won"t execute
}
catch (OverflowException exc) {
// catch the exception
Console.WriteLine(exc);
}
}
}

</source>

==Using checked and unchecked with statement blocks==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Using checked and unchecked with statement blocks.

using System;

public class CheckedBlocks {
public static void Main() {
byte a, b;
byte result;

a = 127;
b = 127;

try {
unchecked {
a = 127;
b = 127;
result = unchecked((byte)(a * b));
Console.WriteLine("Unchecked result: " + result);

a = 125;
b = 5;
result = unchecked((byte)(a * b));
Console.WriteLine("Unchecked result: " + result);
}

checked {
a = 2;
b = 7;
result = checked((byte)(a * b)); // this is OK
Console.WriteLine("Checked result: " + result);

a = 127;
b = 127;
result = checked((byte)(a * b)); // this causes exception
Console.WriteLine("Checked result: " + result); // won"t execute
}
}
catch (OverflowException exc) {
// catch the exception
Console.WriteLine(exc);
}
}
}

</source>

==Using Exception members==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Using Exception members.

using System;

class ExcTest {
public static void genException() {
int[] nums = new int[4];

Console.WriteLine("Before exception is generated.");

// Generate an index out-of-bounds exception.
for(int i=0; i < 10; i++) {
nums[i] = i;
Console.WriteLine("nums[{0}]: {1}", i, nums[i]);
}

Console.WriteLine("this won"t be displayed");
}
}

public class UseExcept {
public static void Main() {

try {
ExcTest.genException();
}
catch (IndexOutOfRangeException exc) {
// catch the exception
Console.WriteLine("Standard message is: ");
Console.WriteLine(exc); // calls ToString()
Console.WriteLine("Stack trace: " + exc.StackTrace);
Console.WriteLine("Message: " + exc.Message);
Console.WriteLine("TargetSite: " + exc.TargetSite);
}
Console.WriteLine("After catch statement.");
}
}

</source>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/C Sharp/Language Basics/Exception Class - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия