CatchBlock.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Core / Microsoft / Scripting / Ast / CatchBlock.cs / 1305376 / CatchBlock.cs

                            /* **************************************************************************** 
 *
 * Copyright (c) Microsoft Corporation.
 *
 * This source code is subject to terms and conditions of the Microsoft Public License. A 
 * copy of the license can be found in the License.html file at the root of this distribution. If
 * you cannot locate the  Microsoft Public License, please send an email to 
 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Microsoft Public License.
 * 
 * You must not remove this notice, or any other, from this software.
 *
 *
 * ***************************************************************************/ 

using System.Diagnostics; 
using System.Dynamic.Utils; 

#if SILVERLIGHT 
using System.Core;
#endif

namespace System.Linq.Expressions { 

    ///  
    /// Represents a catch statement in a try block. 
    /// This must have the same return type (i.e., the type of ) as the try block it is associated with.
    ///  
#if !SILVERLIGHT
    [DebuggerTypeProxy(typeof(Expression.CatchBlockProxy))]
#endif
    public sealed class CatchBlock { 
        private readonly Type _test;
        private readonly ParameterExpression _var; 
        private readonly Expression _body; 
        private readonly Expression _filter;
 
        internal CatchBlock(Type test, ParameterExpression variable, Expression body, Expression filter) {
            _test = test;
            _var = variable;
            _body = body; 
            _filter = filter;
        } 
 
        /// 
        /// Gets a reference to the  object caught by this handler. 
        /// 
        public ParameterExpression Variable {
            get { return _var; }
        } 

        ///  
        /// Gets the type of  this handler catches. 
        /// 
        public Type Test { 
            get { return _test; }
        }

        ///  
        /// Gets the body of the catch block.
        ///  
        public Expression Body { 
            get { return _body; }
        } 

        /// 
        /// Gets the body of the 's filter.
        ///  
        public Expression Filter {
            get { 
                return _filter; 
            }
        } 

        /// 
        /// Returns a  that represents the current .
        ///  
        /// A  that represents the current . 
        public override string ToString() { 
            return ExpressionStringBuilder.CatchBlockToString(this); 
        }
 
        /// 
        /// Creates a new expression that is like this one, but using the
        /// supplied children. If all of the children are the same, it will
        /// return this expression. 
        /// 
        /// The  property of the result. 
        /// The  property of the result. 
        /// The  property of the result.
        /// This expression if no children changed, or an expression with the updated children. 
        public CatchBlock Update(ParameterExpression variable, Expression filter, Expression body) {
            if (variable == Variable && filter == Filter && body == Body) {
                return this;
            } 
            return Expression.MakeCatchBlock(Test, variable, body, filter);
        } 
    } 

    public partial class Expression { 
        /// 
        /// Creates a  representing a catch statement.
        /// The  of object to be caught can be specified but no reference to the object
        /// will be available for use in the . 
        /// 
        /// The  of  this  will handle. 
        /// The body of the catch statement. 
        /// The created .
        public static CatchBlock Catch(Type type, Expression body) { 
            return MakeCatchBlock(type, null, body, null);
        }

        ///  
        /// Creates a  representing a catch statement with a reference to the caught object for use in the handler body.
        ///  
        /// A  representing a reference to the  object caught by this handler. 
        /// The body of the catch statement.
        /// The created . 
        public static CatchBlock Catch(ParameterExpression variable, Expression body) {
            ContractUtils.RequiresNotNull(variable, "variable");
            return MakeCatchBlock(variable.Type, variable, body, null);
        } 

        ///  
        /// Creates a  representing a catch statement with 
        /// an  filter but no reference to the caught  object.
        ///  
        /// The  of  this  will handle.
        /// The body of the catch statement.
        /// The body of the  filter.
        /// The created . 
        public static CatchBlock Catch(Type type, Expression body, Expression filter) {
            return MakeCatchBlock(type, null, body, filter); 
        } 

        ///  
        /// Creates a  representing a catch statement with
        /// an  filter and a reference to the caught  object.
        /// 
        /// A  representing a reference to the  object caught by this handler. 
        /// The body of the catch statement.
        /// The body of the  filter. 
        /// The created . 
        public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter) {
            ContractUtils.RequiresNotNull(variable, "variable"); 
            return MakeCatchBlock(variable.Type, variable, body, filter);
        }

        ///  
        /// Creates a  representing a catch statement with the specified elements.
        ///  
        /// The  of  this  will handle. 
        /// A  representing a reference to the  object caught by this handler.
        /// The body of the catch statement. 
        /// The body of the  filter.
        /// The created .
        ///  must be non-null and match the type of  (if it is supplied).
        public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter) { 
            ContractUtils.RequiresNotNull(type, "type");
            ContractUtils.Requires(variable == null || TypeUtils.AreEquivalent(variable.Type, type), "variable"); 
            if (variable != null && variable.IsByRef) { 
                throw Error.VariableMustNotBeByRef(variable, variable.Type);
            } 
            RequiresCanRead(body, "body");
            if (filter != null) {
                RequiresCanRead(filter, "filter");
                if (filter.Type != typeof(bool)) throw Error.ArgumentMustBeBoolean(); 
            }
 
            return new CatchBlock(type, variable, body, filter); 
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK