ArcGIS Pro 2.7 API Reference Guide
GetName(Object) Method
Example 

ArcGIS.Core.Data Namespace > CodedValueDomain Class > GetName Method : GetName(Object) Method
Coded value for which a name should be returned.
Gets the name of a given coded value. This method must be called on the MCT. Use QueuedTask.Run.
Syntax
public string GetName( 
   object value
)
Public Overloads Function GetName( _
   ByVal value As Object _
) As String

Parameters

value
Coded value for which a name should be returned.

Return Value

A name for the coded value. If value does not exist in the domain, an empty string is returned.
Exceptions
ExceptionDescription
A geodatabase-related exception has occurred.
Remarks
The name is often the human readable description of the coded value.
Example
/*

   Copyright 2018 Esri

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and
   limitations under the License.

*/
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ArcGIS.Core.Data;
using ArcGIS.Desktop.Framework.Threading.Tasks;

namespace SDKExamples.GeodatabaseSDK
{
  /// <summary>
  /// Illustrates how to use the CodedValueDomain object.
  /// </summary>
  /// 
  /// <remarks>
  /// <para>
  /// While it is true classes that are derived from the <see cref="ArcGIS.Core.CoreObjectsBase"/> super class 
  /// consumes native resources (e.g., <see cref="ArcGIS.Core.Data.Geodatabase"/> or <see cref="ArcGIS.Core.Data.FeatureClass"/>), 
  /// you can rest assured that the garbage collector will properly dispose of the unmanaged resources during 
  /// finalization.  However, there are certain workflows that require a <b>deterministic</b> finalization of the 
  /// <see cref="ArcGIS.Core.Data.Geodatabase"/>.  Consider the case of a file geodatabase that needs to be deleted 
  /// on the fly at a particular moment.  Because of the <b>indeterministic</b> nature of garbage collection, we can't
  /// count on the garbage collector to dispose of the Geodatabase object, thereby removing the <b>lock(s)</b> at the  
  /// moment we want. To ensure a deterministic finalization of important native resources such as a 
  /// <see cref="ArcGIS.Core.Data.Geodatabase"/> or <see cref="ArcGIS.Core.Data.FeatureClass"/>, you should declare 
  /// and instantiate said objects in a <b>using</b> statement.  Alternatively, you can achieve the same result by 
  /// putting the object inside a try block and then calling Dispose() in a finally block.
  /// </para>
  /// <para>
  /// In general, you should always call Dispose() on the following types of objects: 
  /// </para>
  /// <para>
  /// - Those that are derived from <see cref="ArcGIS.Core.Data.Datastore"/> (e.g., <see cref="ArcGIS.Core.Data.Geodatabase"/>).
  /// </para>
  /// <para>
  /// - Those that are derived from <see cref="ArcGIS.Core.Data.Dataset"/> (e.g., <see cref="ArcGIS.Core.Data.Table"/>).
  /// </para>
  /// <para>
  /// - <see cref="ArcGIS.Core.Data.RowCursor"/> and <see cref="ArcGIS.Core.Data.RowBuffer"/>.
  /// </para>
  /// <para>
  /// - <see cref="ArcGIS.Core.Data.Row"/> and <see cref="ArcGIS.Core.Data.Feature"/>.
  /// </para>
  /// <para>
  /// - <see cref="ArcGIS.Core.Data.Selection"/>.
  /// </para>
  /// <para>
  /// - <see cref="ArcGIS.Core.Data.VersionManager"/> and <see cref="ArcGIS.Core.Data.Version"/>.
  /// </para>
  /// </remarks>
  public class CodedValueDomainMethods
  {
    /// <summary>
    /// In order to illustrate that Geodatabase calls have to be made on the MCT
    /// </summary>
    /// <returns></returns>
    public async Task CodedValueDomainMethodsAsync()
    {
      await QueuedTask.Run(() => MainMethodCode());
    }

    public void MainMethodCode()
    {
      // Opening a Non-Versioned SQL Server instance.

      DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
      {
        AuthenticationMode = AuthenticationMode.DBMS,

        // Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
        Instance = @"testMachine\testInstance",

        // Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
        Database = "LocalGovernment",

        // Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
        User     = "gdb",
        Password = "password",
        Version  = "dbo.DEFAULT"
      };
      
      using (Geodatabase geodatabase   = new Geodatabase(connectionProperties))
      using (FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.FacilitySite"))
      {
        FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition();

        int facilityCodeIndex = featureClassDefinition.FindField("FCODE");
        Field field           = featureClassDefinition.GetFields()[facilityCodeIndex];
        Domain domain         = field.GetDomain(featureClassDefinition.GetSubtypes().FirstOrDefault(
          subtype => subtype.GetName().ToLowerInvariant().Contains("agriculture")));

        CodedValueDomain codedValueDomain = (CodedValueDomain)domain;

        // Will be "Agriculture Food and Livestock FCode"'.
        string name = codedValueDomain.GetName();

        // Will be FieldType.String'.
        FieldType fieldType = codedValueDomain.GetFieldType();

        // Will be "The type of agriculture, food and livestock facility"'.
        string description = codedValueDomain.GetDescription();

        // Will be 13 since there are 13 code value pairs in this domain'.
        int numberOfcodedValues = codedValueDomain.GetCount();

        // This will be a the code value pairs sorted (in this case) by the codes' increasing integer value.
        SortedList<object, string> codedValuePairs = codedValueDomain.GetCodedValuePairs(); 

        FeatureClassDefinition siteAddressPointDefinition = geodatabase.GetDefinition<FeatureClassDefinition>("LocalGovernment.GDB.SiteAddressPoint");
        int unitTypeIndex                                 = siteAddressPointDefinition.FindField("UNITTYPE");
        Field unitTypeField                               = siteAddressPointDefinition.GetFields()[unitTypeIndex];
        Domain addressUnitTypeDomain                      = unitTypeField.GetDomain();

        CodedValueDomain valueDomain = (CodedValueDomain)addressUnitTypeDomain;

        // Will be Apartment.
        string aptCodeDescription = valueDomain.GetName("APT");

        // Will be Basement.
        string bsmtCodeDescription = valueDomain.GetName("BSMT");

        // Will be DEPT. Make sure you know the domain's FieldType is String before cast.
        string departmentCode = valueDomain.GetCodedValue("Department") as string;

        // Will be FL.
        string floorCode = valueDomain.GetCodedValue("Floor") as string; 
      }
    }
  }
}
Requirements

Target Platforms: Windows 10, Windows 8.1

See Also

Reference

CodedValueDomain Class
CodedValueDomain Members
Overload List