ElementInit.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 / ElementInit.cs / 1305376 / ElementInit.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; 
using System.Collections.Generic; 
using System.Collections.ObjectModel;
using System.Reflection; 
using System.Text;
using System.Dynamic.Utils;

#if SILVERLIGHT 
using System.Core;
#endif 
 
namespace System.Linq.Expressions {
    ///  
    /// Represents the initialization of a list.
    /// 
    public sealed class ElementInit : IArgumentProvider {
        private MethodInfo _addMethod; 
        private ReadOnlyCollection _arguments;
 
        internal ElementInit(MethodInfo addMethod, ReadOnlyCollection arguments) { 
            _addMethod = addMethod;
            _arguments = arguments; 
        }
        /// 
        /// Gets the  used to add elements to the object.
        ///  
        public MethodInfo AddMethod {
            get { return _addMethod; } 
        } 

        ///  
        /// Gets the list of elements to be added to the object.
        /// 
        public ReadOnlyCollection Arguments {
            get { return _arguments; } 
        }
 
        Expression IArgumentProvider.GetArgument(int index) { 
            return _arguments[index];
        } 

        int IArgumentProvider.ArgumentCount {
            get {
                return _arguments.Count; 
            }
        } 
 
        /// 
        /// Creates a  representation of the node. 
        /// 
        /// A  representation of the node.
        public override string ToString() {
            return ExpressionStringBuilder.ElementInitBindingToString(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.
        /// This expression if no children changed, or an expression with the updated children. 
        public ElementInit Update(IEnumerable arguments) {
            if (arguments == Arguments) { 
                return this; 
            }
            return Expression.ElementInit(AddMethod, arguments); 
        }
    }

 
    public partial class Expression {
        ///  
        /// Creates an ElementInit expression that represents the initialization of a list. 
        /// 
        /// The  for the list's Add method. 
        /// An array containing the Expressions to be used to initialize the list.
        /// The created ElementInit expression.
        public static ElementInit ElementInit(MethodInfo addMethod, params Expression[] arguments) {
            return ElementInit(addMethod, arguments as IEnumerable); 
        }
 
        ///  
        /// Creates an ElementInit expression that represents the initialization of a list.
        ///  
        /// The  for the list's Add method.
        /// An  containing  elements to initialize the list.
        /// The created ElementInit expression.
        public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable arguments) { 
            ContractUtils.RequiresNotNull(addMethod, "addMethod");
            ContractUtils.RequiresNotNull(arguments, "arguments"); 
 
            var argumentsRO = arguments.ToReadOnly();
 
            RequiresCanRead(argumentsRO, "arguments");
            ValidateElementInitAddMethodInfo(addMethod);
            ValidateArgumentTypes(addMethod, ExpressionType.Call, ref argumentsRO);
            return new ElementInit(addMethod, argumentsRO); 
        }
 
        private static void ValidateElementInitAddMethodInfo(MethodInfo addMethod) { 
            ValidateMethodInfo(addMethod);
            ParameterInfo[] pis = addMethod.GetParametersCached(); 
            if (pis.Length == 0) {
                throw Error.ElementInitializerMethodWithZeroArgs();
            }
            if (!addMethod.Name.Equals("Add", StringComparison.OrdinalIgnoreCase)) { 
                throw Error.ElementInitializerMethodNotAdd();
            } 
            if (addMethod.IsStatic) { 
                throw Error.ElementInitializerMethodStatic();
            } 
            foreach (ParameterInfo pi in pis) {
                if (pi.ParameterType.IsByRef) {
                    throw Error.ElementInitializerMethodNoRefOutParam(pi.Name, addMethod.Name);
                } 
            }
        } 
    } 
}

// 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