AddInAdapter.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 / AddIn / AddIn / System / Addin / Hosting / Store / AddInAdapter.cs / 1305376 / AddInAdapter.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class:  AddInAdapter 
**
** Purpose: Represents an add-in adapter on disk 
**
===========================================================*/
using System;
using System.Collections.Generic; 
using System.Collections.ObjectModel;
using System.Globalization; 
using System.Reflection; 
using System.Text;
using System.AddIn.MiniReflection; 
using System.Diagnostics.Contracts;

namespace System.AddIn
{ 
    [Serializable]
    internal sealed class AddInAdapter : PipelineComponent 
    { 
        private List _contracts;
        private List _constructors; 

        public AddInAdapter(TypeInfo typeInfo, String assemblyLocation) : base(typeInfo, assemblyLocation)
        {
            _contracts = new List(); 
            _constructors = new List();
        } 
 
        public List Constructors {
            get { return _constructors; } 
        }

        public List Contracts {
            get { return _contracts; } 
        }
 
        public override String ToString() 
        {
            return String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterToString, Name, BestAvailableLocation); 
        }

        internal override bool Validate(Type type, Collection warnings)
        { 
            System.Diagnostics.Contracts.Contract.Assert(type.Assembly.ReflectionOnly && IContractInReflectionLoaderContext.Assembly.ReflectionOnly,
                "Both the type and IContract should be in the ReflectionOnly loader context"); 
 
            if (!type.IsMarshalByRef)
            { 
                warnings.Add(String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterMustBeMBRO, type.AssemblyQualifiedName));
                return false;
            }
 
            //if (!type.Implements(typeofIContract))
            if (!IContractInReflectionLoaderContext.IsAssignableFrom(type)) 
            { 
                warnings.Add(String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterMustImplementAnAddInContract, type.AssemblyQualifiedName));
                return false; 
            }

            foreach (Type contractInterface in type.GetInterfaces())
            { 
                //if (contractInterface.Implements(typeofIContract))
                if (IContractInReflectionLoaderContext.IsAssignableFrom(contractInterface)) 
                    _contracts.Add(new TypeInfo(contractInterface)); 
            }
            if (_contracts.Count == 0) 
            {
                warnings.Add(String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterMustImplementAnAddInContract, type.AssemblyQualifiedName));
                return false;
            } 

            foreach (ConstructorInfo ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) 
            { 
                ParameterInfo[] pars = ctor.GetParameters();
                if (pars.Length != 1) 
                {
                    warnings.Add(String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterOneUnusableConstructor, type.AssemblyQualifiedName));
                    continue;
                } 
                _constructors.Add(new TypeInfo(pars[0].ParameterType));
            } 
            if (_constructors.Count == 0) 
            {
                warnings.Add(String.Format(CultureInfo.CurrentCulture, Res.AddInAdapterNoUsableConstructors, type.AssemblyQualifiedName)); 
                return false;
            }
            return base.Validate(type, warnings);
        } 

 
        // Imagine a generic AddInBase (AB), and an AddInAdapter with a 
        // constructor taking in AB.  If we have IntAddIn : AB,
        // then we should be able to hook this up. 
        internal bool CanConnectTo(AddInBase addInBase)
        {
            System.Diagnostics.Contracts.Contract.Requires(addInBase != null);
 
            if (!addInBase.TypeInfo.IsGeneric)
            { 
                if (this.Constructors.Contains(addInBase.TypeInfo)) 
                    return true;
 
                // return true if we have a constructor that accepts one of addinBase's ActivatableAs base classes
                if (addInBase._activatableAs != null)
                {
                    foreach (TypeInfo activatableAsTypeInfo in addInBase._activatableAs) 
                    {
                        if (this.Constructors.Contains(activatableAsTypeInfo)) 
                            return true; 
                    }
                } 
            }
            else
            {
                return false; 
            }
            return false; 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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