C# Hashtable.StripToStringKeys方法代码示例

    /// <summary>
    /// Updates the custom properties of this Room with propertiesToSet.
    /// Only string-typed keys are applied, new properties (string keys) are added, existing are updated
    /// and if a value is set to null, this will remove the custom property.
    /// </summary>
    /// <remarks>
    /// This method requires you to be connected and be in a room. Otherwise, the local data is updated only as no remote players are known.
    /// Local cache is updated immediately, other players are updated through Photon with a fitting operation.
    /// </remarks>
    /// <param name="propertiesToSet"></param>
    public void SetCustomProperties(Hashtable propertiesToSet)
    {
        if (propertiesToSet == null)
        {
            return;
        }

        // merge (delete null-values)
        this.customProperties.MergeStringKeys(propertiesToSet); // includes a Equals check (simplifying things)
        this.customProperties.StripKeysWithNullValues();

        // send (sync) these new values
        Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;
        PhotonNetwork.networkingPeer.OpSetCustomPropertiesOfActor(this.actorID, customProps, true, 0);
    }

    /// <summary>
    /// Updates the current room's Custom Properties with new/updated key-values. 
    /// </summary>
    /// <remarks>
    /// Custom Properties are a key-value set (Hashtable) which is available to all players in a room.
    /// They can relate to the room or individual players and are useful when only the current value 
    /// of something is of interest. For example: The map of a room.
    /// All keys must be strings.
    /// 
    /// The Room and the PhotonPlayer class both have SetCustomProperties methods.
    /// Also, both classes offer access to current key-values by: customProperties.
    /// 
    /// Always use SetCustomProperties to change values. 
    /// To reduce network traffic, set only values that actually changed.
    /// New properties are added, existing values are updated.
    /// Other values will not be changed, so only provide values that changed or are new.
    /// 
    /// To delete a named (custom) property of this room, use null as value.
    /// 
    /// Locally, SetCustomProperties will update it's cache without delay. 
    /// Other clients are updated through Photon (the server) with a fitting operation.
    /// 
    /// <b>Check and Swap</b>
    /// 
    /// SetCustomProperties have the option to do a server-side Check-And-Swap (CAS): 
    /// Values only get updated if the expected values are correct.
    /// The expectedValues can be different key/values than the propertiesToSet. So you can 
    /// check some key and set another key's value (if the check succeeds).
    /// 
    /// If the client's knowledge of properties is wrong or outdated, it can't set values with CAS.
    /// This can be useful to keep players from concurrently setting values. For example: If all players
    /// try to pickup some card or item, only one should get it. With CAS, only the first SetProperties 
    /// gets executed server-side and any other (sent at the same time) fails.
    /// 
    /// The server will broadcast successfully changed values and the local "cache" of customProperties 
    /// only gets updated after a roundtrip (if anything changed).
    /// 
    /// You can do a "webForward": Photon will send the changed properties to a WebHook defined 
    /// for your application.
    /// 
    /// <b>OfflineMode</b>
    /// 
    /// While PhotonNetwork.offlineMode is true, the expectedValues and webForward parameters are ignored.
    /// In OfflineMode, the local customProperties values are immediately updated (without the roundtrip).
    /// </remarks>
    /// <param name="propertiesToSet">The new properties to be set. </param>
    /// <param name="expectedValues">At least one property key/value set to check server-side. Key and value must be correct. Ignored in OfflineMode.</param>
    /// <param name="webForward">Set to true, to forward the set properties to a WebHook, defined for this app (in Dashboard). Ignored in OfflineMode.</param>
    public void SetCustomProperties(Hashtable propertiesToSet, Hashtable expectedValues = null, bool webForward = false)
    {
        if (propertiesToSet == null)
        {
            return;
        }

        if (!PhotonNetwork.offlineMode)
        {
            Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;
            Hashtable customPropsToCheck = expectedValues.StripToStringKeys() as Hashtable;
            PhotonNetwork.networkingPeer.OpSetPropertiesOfRoom(customProps, customPropsToCheck, webForward);
        }
        else
        {
            Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;
            this.InternalCacheProperties(customProps);
            NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnPhotonCustomRoomPropertiesChanged, customProps);
        }
    }

    /// <summary>
    /// Updates and synchronizes the named properties of this Room with the values of propertiesToSet.
    /// </summary>
    /// <remarks>
    /// Any player can set a Room's properties. Room properties are available until changed, deleted or
    /// until the last player leaves the room.
    /// Access them by: Room.CustomProperties (read-only!).
    ///
    /// To reduce network traffic, set only values that actually changed.
    ///
    /// New properties are added, existing values are updated.
    /// Other values will not be changed, so only provide values that changed or are new.
    /// To delete a named (custom) property of this room, use null as value.
    /// Only string-typed keys are applied (everything else is ignored).
    ///
    /// Local cache is updated immediately, other clients are updated through Photon with a fitting operation.
    /// </remarks>
    /// <param name="propertiesToSet">Hashtable of props to udpate, set and sync. See description.</param>
    public void SetCustomProperties(Hashtable propertiesToSet)
    {
        if (propertiesToSet == null)
        {
            return;
        }

        // merge (delete null-values)
        this.customProperties.MergeStringKeys(propertiesToSet); // includes a Equals check (simplifying things)
        this.customProperties.StripKeysWithNullValues();


        // send (sync) these new values
        Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;
        if (!PhotonNetwork.offlineMode)
        {
            PhotonNetwork.networkingPeer.OpSetCustomPropertiesOfRoom(customProps, true, 0);
        }
        NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnPhotonCustomRoomPropertiesChanged, propertiesToSet);
    }

    /// <summary>
    /// Updates the current room's Custom Properties with new/updated key-values. 
    /// </summary>
    /// <remarks>
    /// Custom Properties are a key-value set (Hashtable) which is available to all players in a room.
    /// They can relate to the room or individual players and are useful when only the current value 
    /// of something is of interest. For example: The map of a room.
    /// All keys must be strings.
    /// 
    /// The Room and the PhotonPlayer class both have SetCustomProperties methods.
    /// Also, both classes offer access to current key-values by: customProperties.
    /// 
    /// Always use SetCustomProperties to change values. 
    /// To reduce network traffic, set only values that actually changed.
    /// New properties are added, existing values are updated.
    /// Other values will not be changed, so only provide values that changed or are new.
    /// 
    /// To delete a named (custom) property of this room, use null as value.
    /// 
    /// Locally, SetCustomProperties will update it's cache without delay. 
    /// Other clients are updated through Photon (the server) with a fitting operation.
    /// 
    /// <b>Check and Swap</b>
    /// 
    /// SetCustomProperties have the option to do a server-side Check-And-Swap (CAS): 
    /// Values only get updated if the expected values are correct.
    /// The expectedValues can be different key/values than the propertiesToSet. So you can 
    /// check some key and set another key's value (if the check succeeds).
    /// 
    /// If the client's knowledge of properties is wrong or outdated, it can't set values with CAS.
    /// This can be useful to keep players from concurrently setting values. For example: If all players
    /// try to pickup some card or item, only one should get it. With CAS, only the first SetProperties 
    /// gets executed server-side and any other (sent at the same time) fails.
    /// 
    /// The server will broadcast successfully changed values and the local "cache" of customProperties 
    /// only gets updated after a roundtrip (if anything changed).
    /// 
    /// You can do a "webForward": Photon will send the changed properties to a WebHook defined 
    /// for your application.
    /// 
    /// <b>OfflineMode</b>
    /// 
    /// While PhotonNetwork.offlineMode is true, the expectedValues and webForward parameters are ignored.
    /// In OfflineMode, the local customProperties values are immediately updated (without the roundtrip).
    /// </remarks>
    /// <param name="propertiesToSet">The new properties to be set. </param>
    /// <param name="expectedValues">At least one property key/value set to check server-side. Key and value must be correct. Ignored in OfflineMode.</param>
    /// <param name="webForward">Set to true, to forward the set properties to a WebHook, defined for this app (in Dashboard). Ignored in OfflineMode.</param>
    public void SetCustomProperties(Hashtable propertiesToSet, Hashtable expectedValues = null, bool webForward = false)
    {
        if (propertiesToSet == null)
        {
            return;
        }

        Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;
        Hashtable customPropsToCheck = expectedValues.StripToStringKeys() as Hashtable;


        // no expected values -> set and callback
        bool noCas = customPropsToCheck == null || customPropsToCheck.Count == 0;



        if (!PhotonNetwork.offlineMode)
        {
            PhotonNetwork.networkingPeer.OpSetPropertiesOfRoom(customProps, customPropsToCheck, webForward);
        }

        if (PhotonNetwork.offlineMode || noCas)
        {
            this.InternalCacheProperties(customProps);
            NetworkingPeer.SendMonoMessage(PhotonNetworkingMessage.OnPhotonCustomRoomPropertiesChanged, customProps);
        }
    }

    /// <summary>
    /// Will update properties on the server, if the expectedValues are matching the current (property)values on the server.
    /// </summary>
    /// <remarks>
    /// This variant of SetCustomProperties uses server side Check-And-Swap (CAS) to update valuzes only if the expected values are correct.
    /// The expectedValues can't be null or empty, but they can be different key/values than the propertiesToSet.
    /// 
    /// If the client's knowledge of properties is wrong or outdated, it can't set values (with CAS).
    /// This can be useful to keep players from concurrently setting values. For example: If all players
    /// try to pickup some card or item, only one should get it. With CAS, only the first SetProperties 
    /// gets executed server-side and any other (sent at the same time) fails.
    /// 
    /// The server will broadcast successfully changed values and the local "cache" of customProperties 
    /// only gets updated after a roundtrip (if anything changed).
    /// </remarks>
    /// <param name="propertiesToSet">The new properties to be set. </param>
    /// <param name="expectedValues">At least one property key/value set to check server-side. Key and value must be correct.</param>
    public void SetCustomProperties(Hashtable propertiesToSet, Hashtable expectedValues)
    {
        if (propertiesToSet == null) {
            return;
        }
        if (expectedValues == null || expectedValues.Count == 0) {
            Debug.LogWarning ("SetCustomProperties(props, expected) requires some expectedValues. Use SetCustomProperties(props) to simply set some without check.");
            return;
        }

        if (!PhotonNetwork.offlineMode) {
            Hashtable customProps = propertiesToSet.StripToStringKeys () as Hashtable;
            Hashtable customPropsToCheck = expectedValues.StripToStringKeys () as Hashtable;
            PhotonNetwork.networkingPeer.OpSetPropertiesOfRoom (customProps, false, 0, customPropsToCheck);  // broadcast is always on for CAS
        }
    }

 public bool OpSetCustomPropertiesOfRoom(Hashtable gameProperties, bool broadcast, byte channelId)
 {
     return this.OpSetPropertiesOfRoom(gameProperties.StripToStringKeys(), broadcast, channelId);
 }

 public bool OpSetCustomPropertiesOfActor(int actorNr, Hashtable actorProperties, bool broadcast, byte channelId)
 {
     return this.OpSetPropertiesOfActor(actorNr, actorProperties.StripToStringKeys(), broadcast, channelId);
 }

    /// <summary>
    /// Updates the custom properties of this Room with propertiesToSet.
    /// Only string-typed keys are applied, new properties (string keys) are added, existing are updated
    /// and if a value is set to null, this will remove the custom property.
    /// </summary>
    /// <remarks>
    /// Local cache is updated immediately, other players are updated through Photon with a fitting operation.
    /// </remarks>
    /// <param name="propertiesToSet"></param>
    public void SetCustomProperties(Hashtable propertiesToSet)
    {
        Hashtable customProps = propertiesToSet.StripToStringKeys() as Hashtable;

        // merge (delete null-values)
        this.customProperties.Merge(customProps);
        this.customProperties.StripKeysWithNullValues();

        // send (sync) these new values
        PhotonNetwork.networkingPeer.OpSetCustomPropertiesOfGame(customProps, true, 0);
    }