PropertyPath.cs source code in C# .NET

                        
Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / PropertyPath.cs / 1 / PropertyPath.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
// File: PropertyPath.cs 
//
// Description: 
//     Used to describe a property as a "path" below another property. 
//
// Example: "Background.Opacity" is a path.  It implies: 
//     * Find the Background property, get the value object of that property.
//     * What we want is the Opacity property on that object.
//
//--------------------------------------------------------------------------- 

using System.ComponentModel; 
using System.Diagnostics; 
using System.Globalization;
using System.Reflection; 
using System.Text;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized; 
using System.Windows.Data;
using System.Windows.Threading; 
 
using System.Windows.Markup;
using MS.Internal; 
using MS.Internal.Data;
using MS.Utility;           // FrugalList

// A property path really consists of two parts: a static part (PropertyPath) 
// that describes the path, and a dynamic part (PropertyPathWorker) that knows
// how to evaluate the path, relative to a "root item". 
// 
// PropertyPath supports two modes of behavior:
// 
// "Source" mode is appropriate when the path describes a "source" - some place
// from which we'll fetch values.  The user of PropertyPath typically creates
// workers explicitly - one for each root item - and calls them directly.  The
// workers are fully dynamic;  they listen for property and currency change 
// events, maintain dependency sources, etc.  The connection between the worker
// and its root item is long-lived.  This mode is used by the Binding class in 
// support of data binding. 
//
// "Target" mode is appropriate when the path describes a "target" - some place 
// into which we'll store values.  The user of PropertyPath typically does not
// create workers, but rather calls the convenience routines in PropertyPath
// (relying on the implicit "single" worker).  The connection between the
// worker and its root item is short-lived;  the caller typically connects to 
// a root item, calls a few methods, then disconnects.  This mode is used by
// the property engine and by animation in support of timeline setters. 
 
namespace System.Windows
{ 
    internal enum PropertyPathStatus { Inactive, Active, PathError, AsyncRequestPending }

    internal struct IndexerParameterInfo
    { 
        public Type type;       // user-specified type
        public object value;    // string or strongly typed value 
    } 

 
    /// 

    /// Data structure for describing a property as a path below another
    /// 
    [TypeConverter(typeof(PropertyPathConverter))] 
    public sealed class PropertyPath
    { 
        //----------------------------------------------------- 
        //
        //  Constructors 
        //
        //-----------------------------------------------------

        /// 
 
        /// Construct a PropertyPath from a string and a list of parameters
        /// 
 
        public PropertyPath(string path, params object[] pathParameters) 
        {
            if (System.Windows.Threading.Dispatcher.CurrentDispatcher == null) 
                throw new InvalidOperationException();  // This is actually never called since CurrentDispatcher will throw if null.

            _path = path;
 
            if (pathParameters.Length > 0)
            { 
                // initialize internal pathParameters list 
                PathParameterCollection parameters = new PathParameterCollection(pathParameters);
                SetPathParameterCollection(parameters); 
            }
            PrepareSourceValueInfo(null);
        }
 
        /// 

        /// Public constructor that takes a single parameter.  This is 
        /// the degenerate PropertyPath (a path of a single step). 
        /// 
        public PropertyPath(object parameter) 
            : this(SingleStepPath, parameter)
        {
        }
 
        // This constructor is for use by the PropertyPathConverter
        internal PropertyPath(string path, ITypeDescriptorContext typeDescriptorContext) 
        { 
            _path = path;
            PrepareSourceValueInfo(typeDescriptorContext); 
            NormalizePath();
        }

        //------------------------------------------------------ 
        //
        //  Public properties 
        // 
        //-----------------------------------------------------
 
        /// 
 The string describing the path. 
        public string Path
        {
            get { return _path; } 
            set
            { 
                _path = value; 
                PrepareSourceValueInfo(null);
            } 
        }

        /// 

        /// The list of parameters to use when the 
        /// path refers to indexed parameters.
        /// Each parameter in the list should be a DependencyProperty, 
        /// a PropertyInfo, or a PropertyDescriptor. 
        /// 
        public Collection