Using ref for value types [closed]

This is done when you want to catch any modifications inside the method you'r calling.

returnedInt is a value type, so he pass it as a reference to ensure the above. returnedOptionSetStringValue is a reference type but the reference to the string is passed by value, so, the same.

Is it a good practice? I don't think so, especially since the method is void. Instead you could return the string and pass the int as an out param.

Methods should only do one thing - in your example I think you should have seperate methods: GetOptionSetLabel and GetOptionSetValue.

I'm always wary of public static void methods as well. I would expect something more like this (tracing code ommitted):

public class YourSensibleClassName
{
    private IOrganizationService organizationService;

    // Constructor injection with a DI framework?
    public YourSensibleClassName(IOrganizationService service)
    {
        this.organizationService = service;
    }    

    public int GetOptionSetValue(
        string entityName, 
        string attributeName, 
        string optionSetText, 
        ITracingService tracerService)
    {
        var optionSetLabels = GetOptionSetLabels(entityName, attributeName);

        var result = optionSetLabels
            .FirstOrDefault(
                label => label.Label.UserLocalizedLabel.Label.Equals(optionSetText));

        if (result == null) 
        {
            throw new Exception(
                string.Format(
                    "No value exists for the specifed optionSetText {0}", 
                    optionSetText));
        }

        return result;
    }

    public string GetOptionSetText(
        string entityName, 
        string attributeName, 
        int optionSetValue, 
        ITracingService tracerService)
    {
        // Code to get the text from the value
    }

    private OptionMetadataCollection GetOptionSetLabels(
        string entityName, 
        string attributeName)
    {
        // Code to get the OptionMetadataCollection and this method needs refactoring too:
        // RetrieveOptionSetMetaDataCollection(ref this.organisationService, entityName, attributeName);
    }
}

I'd expect this to be called like:

YourSensibleClassName c = new YourSensibleClassName(CRMAccess.xrmService);

var optionSetValue = c.GetOptionSetValue(
    Contact.EntityLogicalName, 
    "new_status", 
    "the option set text", 
    CRMAccess.tracerService);

Judging by similar code I've seen written by people, I would think that your Solution Architect comes from a VB6 and before background and hasn't quite made the transition to C#. I'd also be worried by the lack of consistency with parameter names (both camel and Pascal case used), not using built in methods (e.g. using == string.Empty instead of string.IsNullOrEmpty(string)), using a foreach loop when Linq offers a much shorter and clearer way of achieving the goal (although internally doing roughly the same thing) and a clear obsession with ref parameters.

Just to add, one particular dev who coded like this created a method which required over 20 arrays passed by reference... It still makes me shudder.