Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

429 lines
13 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.ComIntegration
{
using System;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Description;
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using System.EnterpriseServices;
using System.Reflection;
using System.Runtime.InteropServices;
using System.ServiceModel;
using System.ServiceModel.Configuration;
using System.Transactions;
using SR = System.ServiceModel.SR;
using System.ServiceModel.Diagnostics;
using System.Runtime;
// The values of the enum are reflected from the values in the
// COM+ Admin SDK.
//
enum Bitness
{
Bitness32 = 0x01,
Bitness64 = 0x02
}
enum ThreadingModel
{
MTA,
STA
}
enum HostingMode
{
ComPlus, // Living in a DllHost.exe
WebHostOutOfProcess, // From webhost to dllhost.exe
WebHostInProcess // Inside webhost
}
class ServiceInfo
{
ServiceElement service;
Guid clsid;
Guid appid;
HostingMode hostingMode;
Guid partitionId;
Bitness bitness;
ThreadingModel threadingModel;
TransactionOption transactionOption;
IsolationLevel isolationLevel;
bool checkRoles;
string[] componentRoleMembers;
bool objectPoolingEnabled;
int maxPoolSize;
Type managedType;
List<ContractInfo> contracts;
string serviceName;
Dictionary<Guid, List<Type>> udts;
public string ServiceName
{
get
{
return serviceName;
}
}
// NOTE: Construction of this thing is quite inefficient-- it
// has several nested loops that could probably be
// improved. Such optimizations have been left for when
// it turns out to be a performance problem, for the
// sake of simplicity.
//
public ServiceInfo(Guid clsid,
ServiceElement service,
ComCatalogObject application,
ComCatalogObject classObject,
HostingMode hostingMode)
{
// Simple things...
//
this.service = service;
this.clsid = clsid;
this.appid = Fx.CreateGuid((string)application.GetValue("ID"));
this.partitionId = Fx.CreateGuid((string)application.GetValue("AppPartitionID"));
this.bitness = (Bitness)classObject.GetValue("Bitness");
this.transactionOption = (TransactionOption)classObject.GetValue("Transaction");
this.hostingMode = hostingMode;
this.managedType = TypeCacheManager.ResolveClsidToType(clsid);
this.serviceName = application.Name + "." + classObject.Name;
this.udts = new Dictionary<Guid, List<Type>>();
// Isolation Level
COMAdminIsolationLevel adminIsolationLevel;
adminIsolationLevel = (COMAdminIsolationLevel)classObject.GetValue("TxIsolationLevel");
switch (adminIsolationLevel)
{
case COMAdminIsolationLevel.Any:
this.isolationLevel = IsolationLevel.Unspecified;
break;
case COMAdminIsolationLevel.ReadUncommitted:
this.isolationLevel = IsolationLevel.ReadUncommitted;
break;
case COMAdminIsolationLevel.ReadCommitted:
this.isolationLevel = IsolationLevel.ReadCommitted;
break;
case COMAdminIsolationLevel.RepeatableRead:
this.isolationLevel = IsolationLevel.RepeatableRead;
break;
case COMAdminIsolationLevel.Serializable:
this.isolationLevel = IsolationLevel.Serializable;
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(
SR.GetString(SR.InvalidIsolationLevelValue,
this.clsid, adminIsolationLevel)));
}
// Threading Model
//
COMAdminThreadingModel adminThreadingModel;
adminThreadingModel = (COMAdminThreadingModel)classObject.GetValue("ThreadingModel");
switch (adminThreadingModel)
{
case COMAdminThreadingModel.Apartment:
case COMAdminThreadingModel.Main:
this.threadingModel = ThreadingModel.STA;
objectPoolingEnabled = false;
break;
default:
this.threadingModel = ThreadingModel.MTA;
objectPoolingEnabled = (bool)classObject.GetValue("ObjectPoolingEnabled");
break;
}
// Object Pool settings
//
if (objectPoolingEnabled)
{
maxPoolSize = (int)classObject.GetValue("MaxPoolSize");
}
else
maxPoolSize = 0;
// Security Settings
//
bool appSecurityEnabled;
appSecurityEnabled = (bool)application.GetValue(
"ApplicationAccessChecksEnabled");
if (appSecurityEnabled)
{
bool classSecurityEnabled;
classSecurityEnabled = (bool)classObject.GetValue(
"ComponentAccessChecksEnabled");
if (classSecurityEnabled)
{
this.checkRoles = true;
}
}
// Component Roles
//
ComCatalogCollection roles;
roles = classObject.GetCollection("RolesForComponent");
this.componentRoleMembers = CatalogUtil.GetRoleMembers(application, roles);
// Contracts
// One ContractInfo per unique IID exposed, so we need to
// filter duplicates.
//
this.contracts = new List<ContractInfo>();
ComCatalogCollection interfaces;
interfaces = classObject.GetCollection("InterfacesForComponent");
foreach (ServiceEndpointElement endpoint in service.Endpoints)
{
ContractInfo contract = null;
if (endpoint.Contract == ServiceMetadataBehavior.MexContractName)
continue;
Guid iid;
if (DiagnosticUtility.Utility.TryCreateGuid(endpoint.Contract, out iid))
{
// (Filter duplicates.)
bool duplicate = false;
foreach (ContractInfo otherContract in this.contracts)
{
if (iid == otherContract.IID)
{
duplicate = true;
break;
}
}
if (duplicate) continue;
foreach (ComCatalogObject interfaceObject in interfaces)
{
Guid otherInterfaceID;
if (DiagnosticUtility.Utility.TryCreateGuid((string)interfaceObject.GetValue("IID"), out otherInterfaceID))
{
if (otherInterfaceID == iid)
{
contract = new ContractInfo(iid,
endpoint,
interfaceObject,
application);
break;
}
}
}
}
if (contract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(
SR.GetString(SR.EndpointNotAnIID,
clsid.ToString("B").ToUpperInvariant(),
endpoint.Contract)));
}
this.contracts.Add(contract);
}
}
public Type ServiceType
{
get { return this.managedType; }
}
public ServiceElement ServiceElement
{
get { return this.service; }
}
public Guid Clsid
{
get { return this.clsid; }
}
public Guid AppID
{
get { return this.appid; }
}
public Guid PartitionId
{
get { return this.partitionId; }
}
public Bitness Bitness
{
get { return this.bitness; }
}
public bool CheckRoles
{
get { return this.checkRoles; }
}
public ThreadingModel ThreadingModel
{
get { return this.threadingModel; }
}
public TransactionOption TransactionOption
{
get { return this.transactionOption; }
}
public IsolationLevel IsolationLevel
{
get { return this.isolationLevel; }
}
public string[] ComponentRoleMembers
{
get { return this.componentRoleMembers; }
}
public List<ContractInfo> Contracts
{
get { return this.contracts; }
}
public HostingMode HostingMode
{
get { return this.hostingMode; }
}
public bool Pooled
{
get { return this.objectPoolingEnabled; }
}
public int MaxPoolSize
{
get { return this.maxPoolSize; }
}
internal Guid[] Assemblies
{
get
{
Guid[] ret = new Guid[this.udts.Keys.Count];
this.udts.Keys.CopyTo(ret, 0);
return ret;
}
}
internal bool HasUdts()
{
// use the assembly count since we only add assemblies when we got UDTs
return (this.udts.Keys.Count > 0);
}
internal Type[] GetTypes(Guid assemblyId)
{
List<Type> ret = null;
udts.TryGetValue(assemblyId, out ret);
if (null == ret)
return new Type[0];
return ret.ToArray();
}
internal void AddUdt(Type udt, Guid assemblyId)
{
if (!udts.ContainsKey(assemblyId))
udts[assemblyId] = new List<Type>();
if (!udts[assemblyId].Contains(udt))
udts[assemblyId].Add(udt);
}
}
class ContractInfo
{
string name;
Guid iid;
string[] interfaceRoleMembers;
List<OperationInfo> operations;
public ContractInfo(Guid iid,
ServiceEndpointElement endpoint,
ComCatalogObject interfaceObject,
ComCatalogObject application)
{
this.name = endpoint.Contract;
this.iid = iid;
// Interface Roles
//
ComCatalogCollection roles;
roles = interfaceObject.GetCollection("RolesForInterface");
this.interfaceRoleMembers = CatalogUtil.GetRoleMembers(application,
roles);
// Operations
//
this.operations = new List<OperationInfo>();
ComCatalogCollection methods;
methods = interfaceObject.GetCollection("MethodsForInterface");
foreach (ComCatalogObject method in methods)
{
this.operations.Add(new OperationInfo(method,
application));
}
}
public string Name
{
get { return this.name; }
}
public Guid IID
{
get { return this.iid; }
}
public string[] InterfaceRoleMembers
{
get { return this.interfaceRoleMembers; }
}
public List<OperationInfo> Operations
{
get { return this.operations; }
}
}
class OperationInfo
{
string name;
string[] methodRoleMembers;
public OperationInfo(ComCatalogObject methodObject,
ComCatalogObject application)
{
this.name = (string)methodObject.GetValue("Name");
// Method Roles
//
ComCatalogCollection roles;
roles = methodObject.GetCollection("RolesForMethod");
this.methodRoleMembers = CatalogUtil.GetRoleMembers(application,
roles);
}
public string Name
{
get { return this.name; }
}
public string[] MethodRoleMembers
{
get { return this.methodRoleMembers; }
}
}
}