ListInitExpression.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 / ListInitExpression.cs / 1305376 / ListInitExpression.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.Collections.Generic; 
using System.Collections.ObjectModel; 
using System.Diagnostics;
using System.Dynamic.Utils; 
using System.Reflection;
using System.Runtime.CompilerServices;

#if SILVERLIGHT 
using System.Core;
#endif 
 
namespace System.Linq.Expressions {
    ///  
    /// Represents a constructor call that has a collection initializer.
    /// 
    /// 
    /// Use the  factory methods to create a ListInitExpression. 
    /// The value of the NodeType property of a ListInitExpression is ListInit.
    ///  
#if !SILVERLIGHT 
    [DebuggerTypeProxy(typeof(Expression.ListInitExpressionProxy))]
#endif 
    public sealed class ListInitExpression : Expression {
        private readonly NewExpression _newExpression;
        private readonly ReadOnlyCollection _initializers;
 
        internal ListInitExpression(NewExpression newExpression, ReadOnlyCollection initializers) {
            _newExpression = newExpression; 
            _initializers = initializers; 
        }
 
        /// 
        /// Returns the node type of this . (Inherited from .)
        /// 
        /// The  that represents this expression. 
        public sealed override ExpressionType NodeType {
            get { return ExpressionType.ListInit; } 
        } 

        ///  
        /// Gets the static type of the expression that this  represents. (Inherited from .)
        /// 
        /// The  that represents the static type of the expression.
        public sealed override Type Type { 
            get { return _newExpression.Type; }
        } 
 
        /// 
        /// Gets a value that indicates whether the expression tree node can be reduced. 
        /// 
        public override bool CanReduce {
            get {
                return true; 
            }
        } 
 
        /// 
        /// Gets the expression that contains a call to the constructor of a collection type. 
        /// 
        public NewExpression NewExpression {
            get { return _newExpression; }
        } 

        ///  
        /// Gets the element initializers that are used to initialize a collection. 
        /// 
        public ReadOnlyCollection Initializers { 
            get { return _initializers; }
        }

        ///  
        /// Dispatches to the specific visit method for this node type.
        ///  
        protected internal override Expression Accept(ExpressionVisitor visitor) { 
            return visitor.VisitListInit(this);
        } 

        /// 
        /// Reduces the binary expression node to a simpler expression.
        /// If CanReduce returns true, this should return a valid expression. 
        /// This method is allowed to return another node which itself
        /// must be reduced. 
        ///  
        /// The reduced expression.
        public override Expression Reduce() { 
            return MemberInitExpression.ReduceListInit(_newExpression, _initializers, true);
        }

        ///  
        /// 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.
        /// This expression if no children changed, or an expression with the updated children.
        public ListInitExpression Update(NewExpression newExpression, IEnumerable initializers) {
            if (newExpression == NewExpression && initializers == Initializers) { 
                return this;
            } 
            return Expression.ListInit(newExpression, initializers); 
        }
    } 


    public partial class Expression {
        ///  
        /// Creates a  that uses a method named "Add" to add elements to a collection.
        ///  
        /// A  to set the  property equal to. 
        /// An array of  objects to use to populate the  collection.
        /// A  that has the  property equal to ListInit and the  property set to the specified value. 
        public static ListInitExpression ListInit(NewExpression newExpression, params Expression[] initializers) {
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers");
            return ListInit(newExpression, initializers as IEnumerable); 
        }
 
        ///  
        /// Creates a  that uses a method named "Add" to add elements to a collection.
        ///  
        /// A  to set the  property equal to.
        /// An  that contains  objects to use to populate the  collection.
        /// A  that has the  property equal to ListInit and the  property set to the specified value.
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable initializers) { 
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers"); 
 
            var initializerlist = initializers.ToReadOnly();
            if (initializerlist.Count == 0) { 
                throw Error.ListInitializerWithZeroMembers();
            }

            MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 
            return ListInit(newExpression, addMethod, initializers);
        } 
 
        /// 
        /// Creates a  that uses a specified method to add elements to a collection. 
        /// 
        /// A  to set the  property equal to.
        /// A  that represents an instance method named "Add" (case insensitive), that adds an element to a collection. 
        /// An array of  objects to use to populate the  collection. 
        /// A  that has the  property equal to ListInit and the  property set to the specified value.
        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, params Expression[] initializers) { 
            if (addMethod == null) { 
                return ListInit(newExpression, initializers as IEnumerable);
            } 
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers");
            return ListInit(newExpression, addMethod, initializers as IEnumerable);
        } 

        ///  
        /// Creates a  that uses a specified method to add elements to a collection. 
        /// 
        /// A  to set the  property equal to. 
        /// A  that represents an instance method named "Add" (case insensitive), that adds an element to a collection. 
        /// An  that contains  objects to use to populate the Initializers collection.
        /// A  that has the  property equal to ListInit and the  property set to the specified value.
        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable initializers) { 
            if (addMethod == null) {
                return ListInit(newExpression, initializers); 
            } 
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers"); 

            var initializerlist = initializers.ToReadOnly();
            if (initializerlist.Count == 0) {
                throw Error.ListInitializerWithZeroMembers(); 
            }
            ElementInit[] initList = new ElementInit[initializerlist.Count]; 
            for (int i = 0; i < initializerlist.Count; i++) { 
                initList[i] = ElementInit(addMethod, initializerlist[i]);
            } 
            return ListInit(newExpression, new TrueReadOnlyCollection(initList));
        }

        ///  
        /// Creates a  that uses specified  objects to initialize a collection.
        ///  
        /// A  to set the  property equal to. 
        /// An array that contains  objects to use to populate the  collection.
        ///  
        /// A  that has the  property equal to ListInit
        /// and the  and  properties set to the specified values.
        /// 
        ///  
        /// The  property of  must represent a type that implements .
        /// The  property of the resulting  is equal to newExpression.Type. 
        ///  
        public static ListInitExpression ListInit(NewExpression newExpression, params ElementInit[] initializers) {
            return ListInit(newExpression, (IEnumerable)initializers); 
        }

        /// 
        /// Creates a  that uses specified  objects to initialize a collection. 
        /// 
        /// A  to set the  property equal to. 
        /// An  that contains  objects to use to populate the  collection. 
        /// An  that contains  objects to use to populate the  collection.
        ///  
        /// The  property of  must represent a type that implements .
        /// The  property of the resulting  is equal to newExpression.Type.
        /// 
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable initializers) { 
            ContractUtils.RequiresNotNull(newExpression, "newExpression");
            ContractUtils.RequiresNotNull(initializers, "initializers"); 
            var initializerlist = initializers.ToReadOnly(); 
            if (initializerlist.Count == 0) {
                throw Error.ListInitializerWithZeroMembers(); 
            }
            ValidateListInitArgs(newExpression.Type, initializerlist);
            return new ListInitExpression(newExpression, initializerlist);
        } 
    }
} 

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