//Microsoft Public License (Ms-PL)
//http://visualizer.codeplex.com/license
using System;
using System.Text;

namespace Redwerb.BizArk.Core.ExceptionExt
{

    /// <summary>
    /// Extensions for classes within the Drawing namespace.
    /// </summary>
    public static class ExceptionExt
    {
        /// <summary>
        /// Gets the details of an exception suitable for display.
        /// </summary>
        /// <param name="ex"></param>
        /// <returns></returns>
        public static string GetDetails(this Exception ex)
        {
            var details = new StringBuilder();

            while (ex != null)
            {
                details.AppendLine(ex.GetType().FullName);
                details.AppendLine(ex.Message);
                details.AppendLine(ex.StackTrace);

                ex = ex.InnerException;
                if (ex != null)
                {
                    details.AppendLine();
                    details.AppendLine(new string(&#039;#&#039;, 70));
                }
            }

            return details.ToString();
        }
    }
}

   
     

   
 
//******************************
// Written by Peter Golde
// Copyright (c) 2004-2007, Wintellect
//
// Use and restribution of this code is subject to the license agreement 
// contained in the file "License.txt" accompanying this file.
//******************************

using System;
using System.Collections;
using System.Collections.Generic;


namespace Wintellect.PowerCollections
{
  /// <summary>
  /// A holder class for various internal utility functions that need to be shared.
  /// </summary>
    internal static class Util
    {
        /// <summary>
        /// Returns the simple name of the class, for use in exception messages. 
        /// </summary>
        /// <returns>The simple name of this class.</returns>
        public static string SimpleClassName(Type type)
        {
            string name = type.Name;

            // Just use the simple name.
            int index = name.IndexOfAny(new char[] { &#039;<&#039;, &#039;{&#039;, &#039;`&#039; });
            if (index >= 0)
                name = name.Substring(0, index);

            return name;
        }
   }
}

   
     

   
 

///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

using System;
using System.Collections.Generic;
using System.Text;

namespace CallButler.Service.Utils
{
    public class ErrorUtils
    {
        public static string FormatErrorString(Exception e)
        {
            StringBuilder sb = new StringBuilder();

            Exception curExp = e;

            while (curExp != null)
            {
                sb.AppendFormat("Source: {0}
Message: {1}
Stack Trace:

{2}", curExp.Source, curExp.Message, curExp.StackTrace);

                curExp = curExp.InnerException;

                if (curExp != null)
                    sb.AppendLine("----------------------------------------");
            }

            return sb.ToString();
        }
    }
}

   
     

   
 
/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa

Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/

// StakTrce.cs -- demonstrates printing the stack trace when an
//                exception is thrown.
//
//                Compile this program with the following command line:
//                    C:>csc /debug:full StakTrce.cs
using System;

namespace nsExceptions
{
    public class StakTrce
    {
        static public void Main ()
        {
            clsTest test = new clsTest();
            test.TestStackTrace ();
        }
    }
    public class clsTest
    {
        public void TestStackTrace ()
        {
            try
            {
                CauseTrouble(1.7);
            }
            catch (Exception e)
            {
                Console.WriteLine (e.StackTrace);
            }
        }
        void CauseTrouble (double val)
        {
            clsAnother nudder = new clsAnother ();
            nudder.MakeProblem ((int) val);
        }
    }
    class clsAnother
    {
        public void MakeProblem (int x)
        {
            throw (new Exception());
        }
    }
}

           
         
     

   
 
/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa

Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/

// EnvTrace.cs -- demonstrates printing the stack trace from the Environment
//                when an exception is not thrown.
//
//                Compile this program with the following command line:
//                    C:>csc /debug:full EnvTrace.cs
using System;
using System.Diagnostics;

namespace nsExceptions
{
    public class EnvTrace
    {
        static public void Main ()
        {
            clsTest test = new clsTest();
            test.TestStackTrace ();
            Console.WriteLine ("
Program completed normally");
        }
    }
    public class clsTest
    {
        public void TestStackTrace ()
        {
            try
            {
                CauseTrouble(1.7);
            }
            catch (Exception e)
            {
                Console.WriteLine (e.StackTrace);
            }
        }
        void CauseTrouble (double val)
        {
            clsAnother nudder = new clsAnother ();
            nudder.MakeProblem ((int) val);
        }
    }
    class clsAnother
    {
        public void MakeProblem (int x)
        {
           Console.WriteLine (Environment.StackTrace); 
        }
    }
}

           
         
     

   

/*
A Programmer's Introduction to C# (Second Edition)
by Eric Gunnerson

Publisher: Apress  L.P.
ISBN: 1-893115-62-3
*/

// 04 - Exception HandlingFinally
// copyright 2000 Eric Gunnerson
using System;
using System.IO;

public class ExceptionHandlingFinally
{
    public static void Main()
    {
        Processor processor = new Processor();
        try
        {
            processor.ProcessFile();
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception: {0}", e);
        }
    }
}

class Processor
{
    int    count;
    int    sum;
    public int average;
    void CalculateAverage(int countAdd, int sumAdd)
    {
        count += countAdd;
        sum += sumAdd;
        average = sum / count;
    }    
    public void ProcessFile()
    {
        FileStream f = new FileStream("data.txt", FileMode.Open);
        try
        {
            StreamReader t = new StreamReader(f);
            string    line;
            while ((line = t.ReadLine()) != null)
            {
                int count;
                int sum;
                count = Convert.ToInt32(line);
                line = t.ReadLine();
                sum = Convert.ToInt32(line);
                CalculateAverage(count, sum);
            }
        }
        // always executed before function exit, even if an
        // exception was thrown in the try.
        finally
        {
            f.Close();
        }
    }
}

           
          

/*
C#: The Complete Reference
by Herbert Schildt

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/

// Use finally.

using System;

class UseFinally {
public static void genException(int what) {
int t;
int[] nums = new int[2];

Console.WriteLine(“Receiving ” + what);
try {
switch(what) {
case 0:
t = 10 / what; // generate div-by-zero error
break;
case 1:
nums[4] = 4; // generate array index error.
break;
case 2:
return; // return from try block
}
}
catch (DivideByZeroException) {
// catch the exception
Console.WriteLine(“Can't divide by Zero!”);
return; // return from catch
}
catch (IndexOutOfRangeException) {
// catch the exception
Console.WriteLine(“No matching element found.”);
}
finally {
Console.WriteLine(“Leaving try.”);
}
}
}

public class FinallyDemo {
public static void Main() {

for(int i=0; i < 3; i++) { UseFinally.genException(i); Console.WriteLine(); } } } [/csharp]