在运行时创建WCF服务

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了在运行时创建WCF服务相关的知识,希望对你有一定的参考价值。

我们将从运行时读取的元数据构建Web服务。我的意思是整个Web服务:签名,合同和实现。

我从这里看到两条主要路径。

第一个路径是您生成代码。您可以在字符串中生成C#代码并在运行中进行编译或更优雅(并且更复杂),您可以发出MSIL代码。这样你就有了WCF代码,WCF将负责从中生成WSDL。

第二条路径是使用通用服务。具有接受所有内容的操作消息进程(消息)的服务。我们仍然希望将服务公开为“普通”服务,因此我需要在某处使用WSDL。我如何创建WSDL?我想到使用System.ServiceModel.Description,直到我意识到内部深处,这个API依赖于具体类型。使用这种方法,我们不会有任何数据协定类型,并且会动态处理XML,使用元数据来解释它。所以我们需要以某种方式生成WSDL。这是一个疯狂的想法吗? WSDL有一个非常复杂的规范......

第三种选择是使用混合方法,发布类型只是为了创建签名,但使用非发射代码实现服务(反映发射的类型)。很奇怪,但可能比手工制作WSDL更简单......

建议?

答案

这样做很痛苦,但可能会散发类型。创建.svc并将其指向您的自定义ServiceHostFactory:

<%@ ServiceHost Language="C#" Debug="true" Factory="Foo.FooServiceHostFactory" %>

[ServiceContract]
public class FooService { }

您的ServiceHostFactory是您生成操作合同,使用它的类型等的地方:

public class FooServiceHostFactory : ServiceHostFactory {
public override System.ServiceModel.ServiceHostBase CreateServiceHost(string constructorString, Uri[] baseAddresses) {
    ServiceHost serviceHost = new FooServiceHost(baseAddresses);
    serviceHost.AddDefaultEndpoints();
    GenerateServiceOperations(serviceHost);
    return serviceHost;
}

private void GenerateServiceOperations(ServiceHost serviceHost) {
    var methodNames = new[] {
        new { Name = "Add" },
        new { Name = "Subtract" },
        new { Name = "Multiply" }
    };

    foreach (var method in methodNames) {
        foreach (var endpoint in serviceHost.Description.Endpoints) {
            var contract = endpoint.Contract;
            var operationDescription = new OperationDescription("Operation" + method.Name, contract);
            var requestMessageDescription = new MessageDescription(string.Format("{0}{1}/Operation{2}", contract.Namespace, contract.Name, method.Name), MessageDirection.Input);
            var responseMessageDescription = new MessageDescription(string.Format("{0}{1}/Operation{2}Response", contract.Namespace, contract.Name, method.Name), MessageDirection.Output);

            var elements = new List<FooDataItem>();
            elements.Add(new FooDataItem { Name = "X", DataType = typeof(int) });
            elements.Add(new FooDataItem { Name = "Y", DataType = typeof(int) });

            //note: for a complex type it gets more complicated, but the same idea using reflection during invoke()
            //object type = TypeFactory.CreateType(method.Name, elements);
            //var arrayOfType = Array.CreateInstance(type.GetType(), 0);

            //var parameter = new MessagePartDescription(method.Name + "Operation", contract.Namespace);
            //parameter.Type = arrayOfType.GetType();
            //parameter.Index = 0;
            //requestMessageDescription.Body.Parts.Add(parameter);

            var retVal = new MessagePartDescription("Result", contract.Namespace);
            retVal.Type = typeof(int);
            responseMessageDescription.Body.ReturnValue = retVal;

            int indexer = 0;
            foreach (var element in elements) {
                var parameter = new MessagePartDescription(element.Name, contract.Namespace);
                parameter.Type = element.DataType;
                parameter.Index = indexer++;
                requestMessageDescription.Body.Parts.Add(parameter);
            }

            operationDescription.Messages.Add(requestMessageDescription);
            operationDescription.Messages.Add(responseMessageDescription);
            operationDescription.Behaviors.Add(new DataContractSerializerOperationBehavior(operationDescription));
            operationDescription.Behaviors.Add(new FooOperationImplementation());
            contract.Operations.Add(operationDescription);
        }
    }
}

protected override System.ServiceModel.ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses) {
    return base.CreateServiceHost(serviceType, baseAddresses);
}

在ServiceHostFactory中,您可以定义行为以及元数据,因此您的行为需要实现IOperationBehavior和IOperationInvoker(或者您可以单独实现它们),看起来像这样:

public class FooOperationImplementation : IOperationBehavior, IOperationInvoker {
OperationDescription operationDescription;
DispatchOperation dispatchOperation;

public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters) {

}

public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation) {

}

public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation) {
    this.operationDescription = operationDescription;
    this.dispatchOperation = dispatchOperation;

    dispatchOperation.Invoker = this;
}

public void Validate(OperationDescription operationDescription) {

}

public object[] AllocateInputs() {
    return new object[2];
}

public object Invoke(object instance, object[] inputs, out object[] outputs) {
    //this would ALL be dynamic as well depending on how you are creating your service
    //for example, you could keep metadata in the database and then look it up, etc
    outputs = new object[0];

    switch (operationDescription.Name) {
        case "OperationAdd":
            return (int)inputs[0] + (int)inputs[1];
        case "OperationSubtract":
            return (int)inputs[0] - (int)inputs[1];
        case "OperationMultiply":
            return (int)inputs[0] * (int)inputs[1];
        default:
            throw new NotSupportedException("wtf");
    }
}

public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state) {
    throw new NotImplementedException("Method is not asynchronous.");
}

public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) {
    throw new NotImplementedException("Method is not asynchronous.");
}

public bool IsSynchronous {
    get { return true; }
}

}

对于复杂类型,这是您需要进行判断调用的地方,这是您的问题的根源,是如何发出类型。这是一个例子,但你可以以任何你认为合适的方式做到这一点。我在我的ServiceHostFactory中调用它(警告:它的演示代码)

static public class TypeFactory {
    static object _lock = new object();
    static AssemblyName assemblyName;
    static AssemblyBuilder assemblyBuilder;
    static ModuleBuilder module;

    static TypeFactory() {
        lock (_lock) {
            assemblyName = new AssemblyName();
            assemblyName.Name = "FooBarAssembly";
            assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
            module = assemblyBuilder.DefineDynamicModule("FooBarModule");
        }
    }

    static public object CreateType(string typeName, List<FooDataItem> elements) {
        TypeBuilder typeBuilder = module.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class);

        foreach(var element in elements) {
            string propertyName = element.Name;
            Type dataType = element.DataType;

            FieldBuilder field = typeBuilder.DefineField("_" + propertyName, dataType, FieldAttributes.Private);
            PropertyBuilder property =
                typeBuilder.DefineProperty(propertyName,
                                    PropertyAttributes.None,
                                    dataType,
                                    new Type[] { dataType });

            MethodAttributes GetSetAttr =
                    MethodAttributes.Public |
                    MethodAttributes.HideBySig;

            MethodBuilder currGetPropMthdBldr =
                typeBuilder.DefineMethod("get_value",
                                            GetSetAttr,
                                            dataType,
                                            Type.EmptyTypes);

            ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
            currGetIL.Emit(OpCodes.Ldarg_0);
            currGetIL.Emit(OpCodes.Ldfld, field);
            currGetIL.Emit(OpCodes.Ret);

            MethodBuilder currSetPropMthdBldr =
                typeBuilder.DefineMethod("set_value",
                                            GetSetAttr,
                                            null,
                                            new Type[] { dataType });

            ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
            currSetIL.Emit(OpCodes.Ldarg_0);
            currSetIL.Emit(OpCodes.Ldarg_1);
            currSetIL.Emit(OpCodes.Stfld, field);
            currSetIL.Emit(OpCodes.Ret);

            property.SetGetMethod(currGetPropMthdBldr);
            property.SetSetMethod(currSetPropM

以上是关于在运行时创建WCF服务的主要内容,如果未能解决你的问题,请参考以下文章

wcf 网络服务未运行

WCF系列教程之WCF服务宿主

在 WCF 启动时运行函数

在IIS上运行C#WCF服务时获取重复记录

当 Fiddler 运行 .Net 4.5 时,WCF 服务正在工作

IIS托管WCF服务:集成测试和代码覆盖