C# Hashtable.Put方法代码示例

		/// <exception cref="NSch.JSchException"></exception>
		public override void Start()
		{
			try
			{
				PipedOutputStream pos = new PipedOutputStream();
				io.SetOutputStream(pos);
				PipedInputStream pis = new Channel.MyPipedInputStream(this, pos, 32 * 1024);
				io.SetInputStream(pis);
				io_in = [email protected];
				if (io_in == null)
				{
					throw new JSchException("channel is down");
				}
				Request request = new RequestSftp();
				request.DoRequest(GetSession(), this);
				buf = new Buffer(rmpsize);
				packet = new Packet(buf);
				int i = 0;
				int length;
				int type;
				byte[] str;
				// send SSH_FXP_INIT
				SendINIT();
				// receive SSH_FXP_VERSION
				ChannelHeader header = new ChannelHeader(this);
				header = Header(buf, header);
				length = header.length;
				if (length > MAX_MSG_LENGTH)
				{
					throw new SftpException(SSH_FX_FAILURE, "Received message is too long: " + length
						);
				}
				type = header.type;
				// 2 -> SSH_FXP_VERSION
				server_version = header.rid;
				//System.err.println("SFTP protocol server-version="+server_version);
				if (length > 0)
				{
					extensions = new Hashtable();
					// extension data
					Fill(buf, length);
					byte[] extension_name = null;
					byte[] extension_data = null;
					while (length > 0)
					{
						extension_name = buf.GetString();
						length -= (4 + extension_name.Length);
						extension_data = buf.GetString();
						length -= (4 + extension_data.Length);
						extensions.Put(Util.Byte2str(extension_name), Util.Byte2str(extension_data));
					}
				}
				lcwd = new FilePath(".").GetCanonicalPath();
			}
			catch (Exception e)
			{
				//System.err.println(e);
				if (e is JSchException)
				{
					throw (JSchException)e;
				}
				if (e is Exception)
				{
					throw new JSchException(e.ToString(), (Exception)e);
				}
				throw new JSchException(e.ToString());
			}
		}

 public bool Run()
 {
     for (int j = 0; j < numberOfDocuments; j++)
     {
         Document doc = docs[j];
         SavedRevision lastSavedRevision = null;
         for (int k = 0; k < numberOfUpdates; k++)
         {
             if (lastSavedRevision != null)
             {
                 NUnit.Framework.Assert.AreEqual(lastSavedRevision.GetId(), doc.GetCurrentRevisionId
                     ());
             }
             IDictionary<string, object> contents = new Hashtable(doc.GetProperties());
             Document docLatest = this._enclosing.database.GetDocument(doc.GetId());
             bool wasChecked = (bool)contents.Get("toogle");
             contents.Put("toogle", !wasChecked);
             try
             {
                 lastSavedRevision = doc.PutProperties(contents);
                 numDocsUpdated.IncrementAndGet();
             }
             catch (CouchbaseLiteException cblex)
             {
                 Log.E(LiteTestCase.Tag, "Document update failed", cblex);
                 numExceptions.IncrementAndGet();
             }
         }
     }
     return true;
 }

        /// <summary>
        /// This specialized method returns a Map of users and local groups for the
        /// target server where keys are SIDs representing an account and each value
        /// is an List<object> of SIDs represents the local groups that the account is
        /// a member of.
        /// </summary>
        /// <remarks>
        /// This specialized method returns a Map of users and local groups for the
        /// target server where keys are SIDs representing an account and each value
        /// is an List<object> of SIDs represents the local groups that the account is
        /// a member of.
        /// <p/>
        /// This method is designed to assist with computing access control for a
        /// given user when the target object's ACL has local groups. Local groups
        /// are not listed in a user's group membership (e.g. as represented by the
        /// tokenGroups constructed attribute retrived via LDAP).
        /// <p/>
        /// Domain groups nested inside a local group are currently not expanded. In
        /// this case the key (SID) type will be SID_TYPE_DOM_GRP rather than
        /// SID_TYPE_USER.
        /// </remarks>
        /// <param name="authorityServerName">The server from which the local groups will be queried.
        /// 	</param>
        /// <param name="auth">The credentials required to query groups and group members.</param>
        /// <param name="flags">
        /// Flags that control the behavior of the operation. When all
        /// name associated with SIDs will be required, the SID_FLAG_RESOLVE_SIDS
        /// flag should be used which causes all group member SIDs to be resolved
        /// together in a single more efficient operation.
        /// </param>
        /// <exception cref="System.IO.IOException"></exception>
        internal static Hashtable GetLocalGroupsMap(string authorityServerName, NtlmPasswordAuthentication
			 auth, int flags)
        {
            Sid domsid = GetServerSid(authorityServerName, auth);
            DcerpcHandle handle = null;
            SamrPolicyHandle policyHandle = null;
            SamrDomainHandle domainHandle = null;
            Samr.SamrSamArray sam = new Samr.SamrSamArray();
            MsrpcEnumerateAliasesInDomain rpc;
            lock (SidCache)
            {
                try
                {
                    handle = DcerpcHandle.GetHandle("ncacn_np:" + authorityServerName + "[\\PIPE\\samr]"
                        , auth);
                    policyHandle = new SamrPolicyHandle(handle, authorityServerName, unchecked(0x02000000));
                    domainHandle = new SamrDomainHandle(handle, policyHandle, unchecked(0x02000000), domsid);
                    rpc = new MsrpcEnumerateAliasesInDomain(domainHandle, unchecked(0xFFFF), sam
                        );
                    handle.Sendrecv(rpc);
                    if (rpc.Retval != 0)
                    {
                        throw new SmbException(rpc.Retval, false);
                    }
                    Hashtable map = new Hashtable();
                    for (int ei = 0; ei < rpc.Sam.Count; ei++)
                    {
                        Samr.SamrSamEntry entry = rpc.Sam.Entries[ei];
                        Sid[] mems = GetGroupMemberSids0(handle, domainHandle, domsid
                            , entry.Idx, flags);
                        Sid groupSid = new Sid(domsid, entry.Idx);
                        groupSid.Type = SidTypeAlias;
                        groupSid.DomainName = domsid.GetDomainName();
                        groupSid.AcctName = (new UnicodeString(entry.Name, false)).ToString();
                        for (int mi = 0; mi < mems.Length; mi++)
                        {
                            List<object> groups = (List<object>)map.Get(mems[mi]);
                            if (groups == null)
                            {
                                groups = new List<object>();
                                map.Put(mems[mi], groups);
                            }
                            if (!groups.Contains(groupSid))
                            {
                                groups.Add(groupSid);
                            }
                        }
                    }
                    return map;
                }
                finally
                {
                    if (handle != null)
                    {
                        if (policyHandle != null)
                        {
                            if (domainHandle != null)
                            {
                                domainHandle.Close();
                            }
                            policyHandle.Close();
                        }
                        handle.Close();
                    }
                }
            }
        }

 /// <summary>https://github.com/couchbase/couchbase-lite-android/issues/220</summary>
 /// <exception cref="System.Exception"></exception>
 public virtual void TestMultiDocumentUpdate()
 {
     int numberOfDocuments = 10;
     int numberOfUpdates = 10;
     Document[] docs = new Document[numberOfDocuments];
     for (int j = 0; j < numberOfDocuments; j++)
     {
         IDictionary<string, object> prop = new Dictionary<string, object>();
         prop.Put("foo", "bar");
         prop.Put("toogle", true);
         Document document = CreateDocumentWithProperties(database, prop);
         docs[j] = document;
     }
     AtomicInteger numDocsUpdated = new AtomicInteger(0);
     AtomicInteger numExceptions = new AtomicInteger(0);
     for (int j_1 = 0; j_1 < numberOfDocuments; j_1++)
     {
         Document doc = docs[j_1];
         for (int k = 0; k < numberOfUpdates; k++)
         {
             IDictionary<string, object> contents = new Hashtable(doc.GetProperties());
             bool wasChecked = (bool)contents.Get("toogle");
             //toggle value of check property
             contents.Put("toogle", !wasChecked);
             try
             {
                 doc.PutProperties(contents);
                 numDocsUpdated.IncrementAndGet();
             }
             catch (CouchbaseLiteException cblex)
             {
                 Log.E(Tag, "Document update failed", cblex);
                 numExceptions.IncrementAndGet();
             }
         }
     }
     NUnit.Framework.Assert.AreEqual(numberOfDocuments * numberOfUpdates, numDocsUpdated
         .Get());
     NUnit.Framework.Assert.AreEqual(0, numExceptions.Get());
 }