C# ServiceName类代码示例

 public BuiltUpService BuildUp(ServiceName name, object target)
 {
     var dependencies = GetInjections(name);
     foreach (var dependency in dependencies)
         dependency.setter(target, dependency.value.Single());
     return new BuiltUpService(dependencies);
 }

 public void EnsureInitialized(ContainerService service, ContainerContext containerContext, ContainerService root)
 {
     if (!Owned)
         return;
     var componentInstance = Instance as IInitializable;
     if (componentInstance == null)
         return;
     if (!initialized)
         lock (this)
             if (!initialized)
             {
                 var name = new ServiceName(Instance.GetType(), service.UsedContracts);
                 if (containerContext.infoLogger != null)
                     containerContext.infoLogger(name, "initialize started");
                 try
                 {
                     componentInstance.Initialize();
                 }
                 catch (Exception e)
                 {
                     throw new SimpleContainerException(string.Format("exception initializing {0}\r\n\r\n{1}", name, root.GetConstructionLog(containerContext)), e);
                 }
                 if (containerContext.infoLogger != null)
                     containerContext.infoLogger(name, "initialize finished");
                 initialized = true;
             }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RequestMessage"/> class.
 /// </summary>
 /// <param name="serviceName">Name of the service.</param>
 /// <param name="username">Authentication username.</param>
 /// <param name="methodName">The name of the authentication method.</param>
 protected RequestMessage(ServiceName serviceName, string username, string methodName)
 {
     _serviceName = serviceName.ToArray();
     _userName = Utf8.GetBytes(username);
     _methodNameBytes = Ascii.GetBytes(methodName);
     _methodName = methodName;
 }

        protected NuGetService(ServiceName serviceName, ServiceHost host)
        {
            Host = host;
            ServiceName = serviceName;

            TempDirectory = Path.Combine(Path.GetTempPath(), "NuGetServices", serviceName.Name);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="RequestMessageHost"/> class.
 /// </summary>
 /// <param name="serviceName">Name of the service.</param>
 /// <param name="username">Authentication username.</param>
 /// <param name="publicKeyAlgorithm">The public key algorithm.</param>
 /// <param name="publicHostKey">The public host key.</param>
 /// <param name="clientHostName">Name of the client host.</param>
 /// <param name="clientUsername">The client username.</param>
 public RequestMessageHost(ServiceName serviceName, string username, string publicKeyAlgorithm, byte[] publicHostKey, string clientHostName, string clientUsername)
     : base(serviceName, username)
 {
     this.PublicKeyAlgorithm = publicKeyAlgorithm;
     this.PublicHostKey = publicHostKey;
     this.ClientHostName = clientHostName;
     this.ClientUsername = clientUsername;
 }

        public WorkService(ServiceName name, ServiceHost host)
            : base(name, host)
        {
            var workConfig = host.Config.GetSection<WorkConfiguration>();

            MaxWorkers = MaxWorkers ?? workConfig.MaxWorkers;
            WorkersPerCore = WorkersPerCore ?? (workConfig.WorkersPerCore ?? DefaultWorkersPerCore);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceRequestMessage"/> class.
        /// </summary>
        /// <param name="serviceName">Name of the service.</param>
        public ServiceRequestMessage(ServiceName serviceName)
        {
#if TUNING
            _serviceName = serviceName.ToArray();
#else
            ServiceName = serviceName;
#endif
        }

 public void RequestMessagePublicKeyConstructorTest()
 {
     ServiceName serviceName = new ServiceName(); // TODO: Initialize to an appropriate value
     string username = string.Empty; // TODO: Initialize to an appropriate value
     string keyAlgorithmName = string.Empty; // TODO: Initialize to an appropriate value
     byte[] keyData = null; // TODO: Initialize to an appropriate value
     RequestMessagePublicKey target = new RequestMessagePublicKey(serviceName, username, keyAlgorithmName, keyData);
     Assert.Inconclusive("TODO: Implement code to verify target");
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RequestMessageHost"/> class.
 /// </summary>
 /// <param name="serviceName">Name of the service.</param>
 /// <param name="username">Authentication username.</param>
 /// <param name="publicKeyAlgorithm">The public key algorithm.</param>
 /// <param name="publicHostKey">The public host key.</param>
 /// <param name="clientHostName">Name of the client host.</param>
 /// <param name="clientUsername">The client username.</param>
 /// <param name="signature">The signature.</param>
 public RequestMessageHost(ServiceName serviceName, string username, string publicKeyAlgorithm, byte[] publicHostKey, string clientHostName, string clientUsername, byte[] signature)
     : base(serviceName, username, "hostbased")
 {
     PublicKeyAlgorithm = Ascii.GetBytes(publicKeyAlgorithm);
     PublicHostKey = publicHostKey;
     ClientHostName = Ascii.GetBytes(clientHostName);
     ClientUsername = Utf8.GetBytes(clientUsername);
     Signature = signature;
 }

 public void MethodNameTest()
 {
     ServiceName serviceName = new ServiceName(); // TODO: Initialize to an appropriate value
     string username = string.Empty; // TODO: Initialize to an appropriate value
     RequestMessage target = new RequestMessage(serviceName, username); // TODO: Initialize to an appropriate value
     string actual;
     actual = target.MethodName;
     Assert.Inconclusive("Verify the correctness of this test method.");
 }

 public void MethodNameTest()
 {
     ServiceName serviceName = new ServiceName(); // TODO: Initialize to an appropriate value
     string username = string.Empty; // TODO: Initialize to an appropriate value
     string keyAlgorithmName = string.Empty; // TODO: Initialize to an appropriate value
     byte[] keyData = null; // TODO: Initialize to an appropriate value
     RequestMessagePublicKey target = new RequestMessagePublicKey(serviceName, username, keyAlgorithmName, keyData); // TODO: Initialize to an appropriate value
     string actual;
     actual = target.MethodName;
     Assert.Inconclusive("Verify the correctness of this test method.");
 }

 /// <summary>
 /// Called when type specific data need to be loaded.
 /// </summary>
 protected override void LoadData()
 {
     var serviceName = this.ReadAsciiString();
     switch (serviceName)
     {
         case "ssh-userauth":
             this.ServiceName = ServiceName.UserAuthentication;
             break;
         case "ssh-connection":
             this.ServiceName = ServiceName.Connection;
             break;
     }
 }

 [Ignore] // placeholder
 public void SignatureTest()
 {
     ServiceName serviceName = new ServiceName(); // TODO: Initialize to an appropriate value
     string username = string.Empty; // TODO: Initialize to an appropriate value
     string keyAlgorithmName = string.Empty; // TODO: Initialize to an appropriate value
     byte[] keyData = null; // TODO: Initialize to an appropriate value
     RequestMessagePublicKey target = new RequestMessagePublicKey(serviceName, username, keyAlgorithmName, keyData); // TODO: Initialize to an appropriate value
     byte[] expected = null; // TODO: Initialize to an appropriate value
     target.Signature = expected;
     var actual = target.Signature;
     Assert.AreEqual(expected, actual);
     Assert.Inconclusive("Verify the correctness of this test method.");
 }

        /// <summary>
        /// Called when type specific data need to be loaded.
        /// </summary>
        protected override void LoadData()
        {
#if TUNING
            ServiceName = ReadBinary().ToServiceName();
#else
            var serviceName = ReadAsciiString();
            switch (serviceName)
            {
                case "ssh-userauth":
                    ServiceName = ServiceName.UserAuthentication;
                    break;
                case "ssh-connection":
                    ServiceName = ServiceName.Connection;
                    break;
            }
#endif
        }

 private Injection[] DetectInjections(ServiceName name)
 {
     var memberSetters = provider.GetMembers(name.Type);
     var result = new Injection[memberSetters.Length];
     for (var i = 0; i < result.Length; i++)
     {
         var member = memberSetters[i].member;
         try
         {
             result[i].value = container.Resolve(member.MemberType(),
                 name.Contracts.Concat(InternalHelpers.ParseContracts(member)));
             result[i].value.CheckSingleInstance();
         }
         catch (SimpleContainerException e)
         {
             const string messageFormat = "can't resolve member [{0}.{1}]";
             throw new SimpleContainerException(string.Format(messageFormat, member.DeclaringType.FormatName(), member.Name), e);
         }
         result[i].setter = memberSetters[i].setter;
     }
     return result;
 }